package resml

import (
	"sync"
)

// 获取进度接口
type GetProgress interface {
	GetProgress() Progress // 获取进度。如果没有进度，则返回 nil。
}

// 进度条
type Progress interface {
	Percent() float64 // 进度百分比，当总量值为 0 时，返回 0
	Current() int64   // 当前进度
	Total() int64     // 总量值
}

// 进度设置
type Process interface {
	SetCurrent(int64) // 将当前进度设置为指定值
	AddCurrent(int64) // 在当前进度上增加指定值
	SetTotal(int64)   // 将总量值设置为指定值
	AddTotal(int64)   // 在总量值上增加指定值
}

type EmptyProgress struct{}

func (p *EmptyProgress) Percent() float64 { return 0 }
func (p *EmptyProgress) Current() int64   { return 0 }
func (p *EmptyProgress) Total() int64     { return 0 }

func NewEmptyProgress() Progress { return &EmptyProgress{} }

// 进度条的通用实现，实现了 Progress 与 Process 接口
type CommonProgress struct {
	mu      sync.Mutex
	current int64
	total   int64
}

// 进度百分比，如 78.56，当总量值为 0 时，返回 0
func (p *CommonProgress) Percent() float64 {
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.total == 0 {
		return 0
	}
	return float64(p.current) / float64(p.total) * 100
}

// 当前进度
func (p *CommonProgress) Current() int64 {
	p.mu.Lock()
	defer p.mu.Unlock()
	return p.current
}

// 总量值
func (p *CommonProgress) Total() int64 {
	p.mu.Lock()
	defer p.mu.Unlock()
	return p.total
}

// 设置当前进度
func (p *CommonProgress) SetCurrent(n int64) {
	p.mu.Lock()
	defer p.mu.Unlock()
	p.current = n
}

// 添加当前进度
func (p *CommonProgress) AddCurrent(n int64) {
	p.mu.Lock()
	defer p.mu.Unlock()
	p.current += n
}

// 设置总量值
func (p *CommonProgress) SetTotal(n int64) {
	p.mu.Lock()
	defer p.mu.Unlock()
	p.total = n
}

// 添加总量值
func (p *CommonProgress) AddTotal(n int64) {
	p.mu.Lock()
	defer p.mu.Unlock()
	p.total += n
}

// 创建通用的进度
func NewCommonProgress(total int64) *CommonProgress { return &CommonProgress{total: total} }
